// pages/myMsg/myMsg.js
import { getMessageList } from '../../api/myMsg'

Page({
  /**
   * 页面的初始数据
   */
  data: {
    messageList: [],
    hasUnread: false,
    loading: false,
    pageParams: {
      pageNo: 1,
      pageSize: 20,
      sender: ''
    },
    hasMore: true,
    debugInfo: ''
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    const studentInfo = wx.getStorageSync('studentInfo');
    const sender = studentInfo ? studentInfo.studentName : null;
    console.log('🚀 消息页面加载，参数:', options)
    
    // 将 sender 设置到 pageParams 中
    this.setData({
      'pageParams.sender': sender
    });
    
    this.addDebugInfo(`页面加载开始，查询发送者: ${sender}`)
    this.loadMessageList()
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('📱 消息页面显示')
    this.addDebugInfo('页面显示')
    
    // 页面显示时重新加载消息列表，更新已读状态
    this.refreshMessageList()
  },

  /**
   * 添加调试信息
   */
  addDebugInfo(info) {
    const timestamp = new Date().toLocaleTimeString()
    const debugLine = `[${timestamp}] ${info}\n`
    console.log('🔍 DEBUG:', info)
    
    this.setData({
      debugInfo: this.data.debugInfo + debugLine
    })
  },

  /**
   * 刷新消息列表（保持当前页码）
   */
  async refreshMessageList() {
    this.addDebugInfo('刷新消息列表')
    await this.loadMessageList()
  },

  /**
   * 加载消息列表
   */
  async loadMessageList() {
    if (this.data.loading) {
      this.addDebugInfo('正在加载中，跳过重复请求')
      return
    }
    
    this.addDebugInfo(`开始加载消息列表，页码: ${this.data.pageParams.pageNo}`)
    this.setData({ loading: true })

    try {
      console.log('📡 发送API请求，参数:', this.data.pageParams)
      this.addDebugInfo(`发送API请求: /app-api/mp/open/chat/record/page`)

      const res = await getMessageList(this.data.pageParams)
      
      console.log('✅ API响应结果:', res)
      this.addDebugInfo(`API响应成功，获取到 ${res.list?.length || 0} 条原始消息`)

      const messageList = res.list || []
      const total = res.total || 0
      
      console.log('📨 原始消息数据:', {
        消息数量: messageList.length,
        总数量: total,
        原始数据: messageList
      })

      if (messageList.length === 0) {
        this.addDebugInfo('接口返回空数据')
        this.setData({
          loading: false,
          hasMore: false
        })
        return
      }

      // 过滤出当前用户发送的消息
      const currentSender = this.data.pageParams.sender
      const filteredMessages = messageList.filter(item => item.sender === currentSender)
      
      console.log('👤 过滤后的当前用户消息:', {
        发送者: currentSender,
        过滤前数量: messageList.length,
        过滤后数量: filteredMessages.length,
        过滤后数据: filteredMessages
      })
      this.addDebugInfo(`过滤出 ${filteredMessages.length} 条当前用户消息`)

      if (filteredMessages.length === 0) {
        this.addDebugInfo('当前用户没有相关消息')
        this.setData({
          loading: false,
          hasMore: false
        })
        return
      }

      // 获取所有唯一的 caseId
      const uniqueCaseIds = [...new Set(filteredMessages.map(item => item.caseId))].filter(Boolean)
      console.log('🎯 获取到唯一 caseId:', uniqueCaseIds)
      this.addDebugInfo(`获取到 ${uniqueCaseIds.length} 个唯一 caseId`)

      // 为每个 caseId 获取最新的消息
      const caseLatestMessages = await this.getLatestMessagesForCases(uniqueCaseIds)
      console.log('📦 各 caseId 的最新消息:', caseLatestMessages)
      this.addDebugInfo(`获取到 ${caseLatestMessages.length} 个对话的最新消息`)

      // 转换数据结构，适配前端显示
      const formattedList = this.formatMessageList(caseLatestMessages)
      
      console.log('🔄 转换后的消息列表:', formattedList)
      this.addDebugInfo('数据结构转换完成')

      // 按时间倒序排列，最新消息在上面
      const sortedList = [...formattedList].sort((a, b) => {
        const timeA = new Date(a.sendTime || a.createTime || Date.now())
        const timeB = new Date(b.sendTime || b.createTime || Date.now())
        return timeB - timeA
      })
      
      console.log('🕒 排序后的消息列表:', sortedList)
      this.addDebugInfo('消息按时间倒序排列完成')

      // 检查是否有未读消息
      const hasUnread = sortedList.some(item => item.readStatus === 0)
      const unreadCount = sortedList.filter(item => item.readStatus === 0).length
      
      console.log('🔴 未读消息统计:', {
        是否有未读: hasUnread,
        未读数量: unreadCount
      })
      this.addDebugInfo(`未读消息: ${unreadCount} 条`)

      const isFirstPage = this.data.pageParams.pageNo === 1
      const newMessageList = isFirstPage ? sortedList : [...this.data.messageList, ...sortedList]
      const hasMore = messageList.length >= this.data.pageParams.pageSize

      this.setData({
        messageList: newMessageList,
        hasUnread: hasUnread,
        hasMore: hasMore,
        loading: false
      })

      this.addDebugInfo(`页面更新完成，当前共 ${newMessageList.length} 个对话`)

    } catch (error) {
      console.error('❌ 加载消息列表失败:', error)
      this.addDebugInfo(`加载失败: ${error.message || error.errMsg || '未知错误'}`)
      
      this.setData({
        loading: false
      })
      
      wx.showToast({
        title: '加载失败',
        icon: 'none'
      })
    }
  },

  /**
   * 为每个 caseId 获取最新的消息
   */
  async getLatestMessagesForCases(caseIds) {
    const latestMessages = []
    
    for (const caseId of caseIds) {
      try {
        // 调用接口获取该 caseId 的所有消息
        const caseMessages = await getMessageList({
          caseId: caseId,
          pageNo: 1,
          pageSize: 100 // 获取足够多的消息以确保能找到最新的一条
        })

        console.log(`📋 CaseId ${caseId} 的所有消息:`, caseMessages.list)
        
        if (caseMessages.list && caseMessages.list.length > 0) {
          // 按时间排序，找到最新的一条消息
          const sortedMessages = caseMessages.list.sort((a, b) => {
            const timeA = a.sendTime || 0
            const timeB = b.sendTime || 0
            return timeB - timeA
          })
          
          const latestMessage = sortedMessages[0]
          latestMessages.push(latestMessage)
          
          console.log(`📋 CaseId ${caseId} 的最新消息:`, latestMessage)
          this.addDebugInfo(`CaseId ${caseId} 找到最新消息`)
        } else {
          this.addDebugInfo(`CaseId ${caseId} 没有消息`)
        }
      } catch (error) {
        console.error(`❌ 获取 caseId ${caseId} 的消息失败:`, error)
        this.addDebugInfo(`获取 CaseId ${caseId} 消息失败: ${error.message}`)
      }
    }
    
    return latestMessages
  },

  /**
   * 从本地存储获取已读状态
   */
  getReadStatusFromStorage() {
    try {
      const readStatus = wx.getStorageSync('messageReadStatus') || {}
      console.log('📖 从本地存储加载已读状态:', readStatus)
      return readStatus
    } catch (error) {
      console.error('❌ 加载已读状态失败:', error)
      return {}
    }
  },

  /**
   * 保存已读状态到本地存储
   */
  saveReadStatusToStorage(readStatus) {
    try {
      wx.setStorageSync('messageReadStatus', readStatus)
      console.log('💾 已读状态已保存到本地存储')
    } catch (error) {
      console.error('❌ 保存已读状态失败:', error)
    }
  },

  /**
   * 转换消息数据结构，适配前端显示
   */
  formatMessageList(messageList) {
    // 获取本地已读状态
    const readStatusMap = this.getReadStatusFromStorage()
    
    return messageList.map(item => {
      const messageId = item.chatId || item.id
      const isRead = !!readStatusMap[messageId]
      const formatTime = this.formatTime(item.sendTime)
      
      return {
        id: messageId,
        caseId: item.caseId,
        title: this.getMessageTitle(item.senderType),
        sender: item.sender || '未知',
        senderType: item.senderType,
        senderId: item.senderId,
        content: item.content || '暂无内容',
        createTime: formatTime,
        sendTime: item.sendTime,
        readStatus: isRead ? 1 : 0, // 使用本地存储的已读状态
        isCurrentUser: item.sender === this.data.pageParams.sender
      }
    })
  },

  /**
   * 根据发送者类型生成消息标题
   */
  getMessageTitle(senderType) {
    const titleMap = {
      '学生': '学生咨询',
      '老师': '老师回复', 
      '咨询师': '专业咨询',
      '系统': '系统通知'
    }
    return titleMap[senderType] || '网络咨询'
  },

  /**
   * 格式化时间戳
   */
  formatTime(timestamp) {
    if (!timestamp) return '未知时间'
    
    const date = new Date(timestamp)
    const now = new Date()
    
    // 如果是今天
    if (date.toDateString() === now.toDateString()) {
      return date.toLocaleTimeString('zh-CN', { 
        hour: '2-digit', 
        minute: '2-digit' 
      })
    }
    
    // 如果是昨天
    const yesterday = new Date(now)
    yesterday.setDate(yesterday.getDate() - 1)
    if (date.toDateString() === yesterday.toDateString()) {
      return '昨天 ' + date.toLocaleTimeString('zh-CN', { 
        hour: '2-digit', 
        minute: '2-digit' 
      })
    }
    
    // 其他情况显示完整日期
    return date.toLocaleDateString('zh-CN') + ' ' + 
           date.toLocaleTimeString('zh-CN', { 
             hour: '2-digit', 
             minute: '2-digit' 
           })
  },

  /**
   * 点击消息项
   */
  onMessageItemTap(e) {
    const { index } = e.currentTarget.dataset
    const message = this.data.messageList[index]
    
    console.log('👆 点击消息:', {
      消息ID: message.id,
      CaseID: message.caseId,
      消息索引: index,
      消息内容: message
    })
    this.addDebugInfo(`点击消息 CaseID: ${message.caseId}, 标题: ${message.title}`)

    // 如果消息未读，标记为已读
    if (message.readStatus === 0) {
      console.log('📝 消息未读，开始标记为已读')
      this.markSingleMessageAsRead(message.id, index)
    } else {
      console.log('📖 消息已读，直接打开')
    }
    
    // 跳转到消息详情页，传递 caseId
    wx.navigateTo({
      url: `/pages/consultDetail/consultDetail?caseId=${message.caseId}`
    })
  },

  /**
   * 标记单个消息为已读（前端方式）
   */
  markSingleMessageAsRead(messageId, index) {
    try {
      console.log(`🎯 开始标记单个消息为已读: ID=${messageId}, Index=${index}`)
      this.addDebugInfo(`开始标记消息 ${messageId} 为已读`)

      // 获取当前已读状态
      const readStatusMap = this.getReadStatusFromStorage()
      
      // 更新已读状态
      readStatusMap[messageId] = true
      
      // 保存到本地存储
      this.saveReadStatusToStorage(readStatusMap)
      
      // 更新页面数据
      const key = `messageList[${index}].readStatus`
      const stillHasUnread = this.data.messageList.some((item, i) => 
        i !== index ? item.readStatus === 0 : false
      )
      
      this.setData({
        [key]: 1,
        hasUnread: stillHasUnread
      })
      
      console.log('✅ 前端标记完成', {
        消息ID: messageId,
        当前未读状态: stillHasUnread
      })
      this.addDebugInfo(`消息 ${messageId} 标记为已读完成`)

    } catch (error) {
      console.error('❌ 标记消息失败:', error)
      this.addDebugInfo(`标记消息失败: ${error.message}`)
    }
  },

  /**
   * 标记所有消息为已读
   */
  markAllAsRead() {
    try {
      console.log('🎯 标记所有消息为已读')
      this.addDebugInfo('开始标记所有消息为已读')
      
      // 获取当前已读状态
      const readStatusMap = this.getReadStatusFromStorage()
      
      // 将所有当前消息标记为已读
      this.data.messageList.forEach(message => {
        if (message.id) {
          readStatusMap[message.id] = true
        }
      })
      
      // 保存到本地存储
      this.saveReadStatusToStorage(readStatusMap)
      
      // 更新页面数据
      const updatedMessageList = this.data.messageList.map(message => ({
        ...message,
        readStatus: 1
      }))
      
      this.setData({
        messageList: updatedMessageList,
        hasUnread: false
      })
      
      console.log('✅ 所有消息标记为已读完成')
      this.addDebugInfo('所有消息标记为已读完成')
      
      wx.showToast({
        title: '已标记所有为已读',
        icon: 'success'
      })
      
    } catch (error) {
      console.error('❌ 标记所有消息失败:', error)
      this.addDebugInfo(`标记所有消息失败: ${error.message}`)
      
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      })
    }
  },

  /**
   * 清空所有已读状态（调试用）
   */
  clearAllReadStatus() {
    try {
      wx.removeStorageSync('messageReadStatus')
      console.log('🧹 已清空所有已读状态')
      this.addDebugInfo('已清空所有已读状态')
      
      // 重新加载消息列表
      this.loadMessageList()
      
      wx.showToast({
        title: '已清空已读状态',
        icon: 'success'
      })
    } catch (error) {
      console.error('❌ 清空已读状态失败:', error)
    }
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    console.log('🔄 用户下拉刷新')
    this.addDebugInfo('用户下拉刷新')

    this.setData({
      pageParams: {
        ...this.data.pageParams,
        pageNo: 1
      }
    })
    
    this.loadMessageList().finally(() => {
      wx.stopPullDownRefresh()
      this.addDebugInfo('下拉刷新完成')
    })
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    console.log('⬇️ 用户上拉触底')
    this.addDebugInfo('用户上拉触底')

    if (!this.data.hasMore) {
      console.log('⏹️ 没有更多数据')
      this.addDebugInfo('没有更多数据，停止加载')
      return
    }

    if (this.data.loading) {
      console.log('⏳ 正在加载中，跳过')
      this.addDebugInfo('正在加载中，跳过重复请求')
      return
    }
    
    this.setData({
      pageParams: {
        ...this.data.pageParams,
        pageNo: this.data.pageParams.pageNo + 1
      }
    })
    
    this.addDebugInfo(`加载下一页: ${this.data.pageParams.pageNo}`)
    this.loadMessageList()
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '我的消息',
      path: '/pages/myMsg/myMsg'
    }
  }
})